home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1996 #15 / Monster Media Number 15 (Monster Media)(July 1996).ISO / prog_c / cuj0696.zip / DWYER.ZIP / SPECTRAL.TST / SPECDEFS.H < prev    next >
Text File  |  1996-03-22  |  12KB  |  336 lines
  1. /* ============ */
  2. /* specdefs.h    */
  3. /* ============ */
  4. /* ==================================================================== */
  5. /*          MACROS AND PROTOTYPES FOR SPECTRAL.CX AND FRIENDS        */
  6. /* ==================================================================== */
  7. # if defined(__SPECTRAL_H__)
  8. #    /* Do Nothing */
  9. # else
  10. #    define    __SPECTRAL_H__
  11.  
  12. # if defined(DEBUG)
  13. #    define    P(S)    S
  14. # else
  15. #    define    P(S)
  16. # endif
  17.  
  18. /* ---------------------------------------------- */
  19. /* CLR_VECTOR - Clears N extended words at A to 0 */
  20. /* ---------------------------------------------- */
  21. #define CLR_VECTOR(N, A)        \
  22.     memset(A, 0, (N)*NE*sizeof(USHORT))
  23. /* ----------------------------------------------------------- */
  24. /* COMPLETE_UV - Computes New Column of Vmat & New Row of Umat */
  25. /* ----------------------------------------------------------- */
  26. #define    COMPLETE_UV(Umat, Vmat, NewT, M, T, R1, R2)        \
  27.     {                                \
  28.     short    i;                            \
  29.     for (i = 1; i < NewT; ++i)                    \
  30.     {                                \
  31.         USHORT  Q[NE], Tmp1[NE];                    \
  32.         XMULT(R1, Vmat + XML(i,1,T), Vmat + XML(i,NewT,T));    \
  33.         XMULT(R2, Vmat + XML(i,2,T), Tmp1);            \
  34.         XRADD(Vmat + XML(i,NewT,T), Tmp1);            \
  35.         XDIV(Vmat + XML(i,NewT,T), M, Q);            \
  36.         XROUND(Q, Q);                        \
  37.         MOD_UROW(Umat, NewT, i, NewT, T, Q);         \
  38.         XRMULT(Q, M);                    \
  39.         XRSUB(Vmat + XML(i,NewT,T), Q);            \
  40.     }                            \
  41.     }
  42. /* ------------------------------------------------------- */
  43. /* DECREASE_Y - Diminishes Y per Step S10 of Spectral Test */
  44. /* ------------------------------------------------------- */
  45. #define    DECREASE_Y(Y, U, K, Zk, N, T)            \
  46.     {                            \
  47.     short    i;                    \
  48.     for (i = 1; i <= N; ++i)            \
  49.     {                        \
  50.         USHORT  UiZk[NE];                \
  51.         XMULT(U + XML(K, i, T), Zk, UiZk);        \
  52.         XRMULT(UiZk, ETWO);                \
  53.         XRSUB(Y + XVL(i), UiZk);            \
  54.     }                        \
  55.     }
  56. /* -------------------------------------------------------------- */
  57. /* DOT - Calculates extended dot product of Row of U and Row of V */
  58. /* -------------------------------------------------------------- */
  59. #define DOT(Nelem, U, RowNumU, V, RowNumV, T, R)    \
  60.     XdotProd(Nelem, U + XML(RowNumU, 1, T), V + XML(RowNumV, 1, T), R)
  61.  
  62. /* -------------------------------------------------------------------- */
  63. /* FINISH UV - Updates U & V matrices per step S4 of Spectral Test    */
  64. /* -------------------------------------------------------------------- */
  65. #define FINISH_UV(Umat, Vmat, NewT, M, T, R)                \
  66.     {                                    \
  67.     short    j;                            \
  68.     for (j = 1; j < NewT; ++j)                    \
  69.     {                                \
  70.         USHORT  Q[NE];                        \
  71.         XDIV(R, M, Q);                        \
  72.         XRMULT(Q, Vmat + XML(j,1,T));                \
  73.         XROUND(Q, Q);                        \
  74.         MOD_UROW(Umat, NewT, j, NewT, T, Q)             \
  75.         XMULT(Vmat + XML(j,1,T), R, Vmat + XML(j,NewT,T));    \
  76.         XRMULT(Q, M);                    \
  77.         XRSUB(Vmat + XML(j,NewT,T), Q);            \
  78.     }                            \
  79.     }
  80. /* ---------------------------------------- */
  81. /* INCREASE_Y - Adds Row K of U to Vector Y */
  82. /* ---------------------------------------- */
  83. #define INCREASE_Y(Y, U, K, N, T)            \
  84.     {                            \
  85.     short    j;                    \
  86.     for (j = 1; j <= N; ++j)             \
  87.     {                        \
  88.         XRADD(Y + XVL(j), U + XML(K, j, T));    \
  89.     }                        \
  90.     }
  91.  
  92. /* ---------------------------------------------------- */
  93. /* INIT_MAT - Initializes space for Matrix of size T*T    */
  94. /* ---------------------------------------------------- */
  95. #define    INIT_MAT(A, T)                    \
  96.     {                            \
  97.     A = (USHORT *) calloc(T*T, NE*sizeof(USHORT));    \
  98.     assert(A != NULL);                \
  99.     }
  100. /* ---------------------------------------------------- */
  101. /* INIT_MAT_2 - Initializes Starting Values in Matrix A    */
  102. /* ---------------------------------------------------- */
  103. #define    INIT_MAT_2(A, Val, T)                           \
  104.     {                                                   \
  105.     XCOPY(Val, A + XML(1,1,T));                     \
  106.     XCOPY(Val, A + XML(2,2,T));                     \
  107.     }
  108. /* -------------------------------------------------- */
  109. /* INIT_R_MAT - Initializes Matrix R When HowMany = 2 */
  110. /* -------------------------------------------------- */
  111. #define    INIT_R_MAT(R11, R12, R21, R22)                  \
  112.     {                                                   \
  113.     XCOPY(EONE, R11);                               \
  114.     XCOPY(EZERO, R12);                              \
  115.     XCOPY(EZERO, R21);                              \
  116.     XCOPY(EONE, R22);                               \
  117.     PRT_RMAT(R11, R12, R21, R22);            \
  118.     }
  119. /* ---------------------------------------------------- */
  120. /* INIT_VEC - Initializes space for a Vector of size T    */
  121. /* ---------------------------------------------------- */
  122. #define INIT_VEC(V, T)                    \
  123.     {                            \
  124.     V = (USHORT *) calloc(T, NE*sizeof(USHORT));    \
  125.     assert(V != NULL);                \
  126.     }
  127. /* -------------------------------------------------------------------- */
  128. /* INIT_UMAT - Initializes 2x2 U matrix before step S4 in Spectral Test */
  129. /* -------------------------------------------------------------------- */
  130. #define INIT_UMAT(Umat, T)                \
  131.     {                            \
  132.     XCOPY(XH, Umat + XML(1,1,T));            \
  133.     XNEG(Umat + XML(1,1,T));            \
  134.     XCOPY(XP, Umat + XML(1,2,T));            \
  135.     XCOPY(XHP, Umat + XML(2,1,T));            \
  136.     XNEG(Umat + XML(2,1,T));            \
  137.     XCOPY(XPP, Umat + XML(2,2,T));            \
  138.     }
  139. /* -------------------------------------------------------------------- */
  140. /* INIT_VMAT - Initializes 2x2 V matrix before step S4 in Spectral Test */
  141. /* -------------------------------------------------------------------- */
  142. #define INIT_VMAT(Vmat, T)                \
  143.     {                            \
  144.     USHORT Sign[NE];                        \
  145.     XCOPY(EONE, Sign);                \
  146.     if (XGT(XPP, EZERO)) XNEG(Sign);        \
  147.     XMULT(Sign, XPP, Vmat + XML(1,1,T));        \
  148.     XMULT(Sign, XHP, Vmat + XML(1,2,T));        \
  149.     XNEG(Sign);                    \
  150.     XMULT(Sign, XP, Vmat + XML(2,1,T));        \
  151.     XMULT(Sign, XH, Vmat + XML(2,2,T));        \
  152.     }
  153. /* -------------------------------------------------------------------- */
  154. /* INIT_UNEW - Initializes first and last elements of new row in Umat    */
  155. /* -------------------------------------------------------------------- */
  156. #define INIT_UNEW(Umat, NewT, R, T)            \
  157.     {                            \
  158.     XCOPY(R, Umat + XML(NewT,1,T));            \
  159.     XNEG(Umat + XML(NewT,1,T));            \
  160.     XCOPY(EONE, Umat + XML(NewT,NewT,T));        \
  161.     }
  162. /* ------------------------------------------------------- */
  163. /* INIT_VNEW - Initializes last element in new row in Vmat */
  164. /* ------------------------------------------------------- */
  165. #define INIT_VNEW(Vmat, NewT, M, T)            \
  166.     {                            \
  167.     XCOPY(M, Vmat + XML(NewT, NewT, T));        \
  168.     }
  169. #define    LDBLPRT(X, N, S)                \
  170.     {                            \
  171.     short   i, j;                    \
  172.     printf("%s\n", S);                \
  173.     for (i = 0; i < N; ++i)                \
  174.     {                        \
  175.         for (j = 0; j < sizeof(long double); ++j)   \
  176.         {                                           \
  177.             printf(" %.4X", ((char *)(X+i))[j]);    \
  178.         }                                           \
  179.         printf("\n");                \
  180.         }                                       \
  181.     }
  182. /* ------------------------------------------------------- */
  183. /* MATPRT - Prints I x I Matrix A Embedded in T x T matrix */
  184. /* ------------------------------------------------------- */
  185. #
  186. # if !defined(DEBUG)
  187. #    define MATPRT(A, I, T, S)
  188. # else
  189. #define MATPRT(A, I, T, S)                \
  190.     {                            \
  191.     XmatPrt(A, I, T, stdout, S);            \
  192.     }
  193. # endif
  194. /* -------------------------------------------------------------------- */
  195. /* MOD_UROW - Modifies row J of U matrix per S4 & S5 of Spectral Test    */
  196. /* -------------------------------------------------------------------- */
  197. #define MOD_UROW(Umat, J, I, N, T, Q)            \
  198.     {                            \
  199.     short    k;                    \
  200.     for (k = 1; k <= N; ++k)            \
  201.     {                        \
  202.         USHORT  QUi[NE];                \
  203.         XMULT(Umat + XML(I, k, T), Q, QUi);        \
  204.         XRADD(Umat + XML(J, k, T), QUi);        \
  205.     }                        \
  206.     }
  207. /* -------------------------------------------------------------------- */
  208. /* MOD_VROW - Modifies row I of V matrix per S5 of Spectral Test    */
  209. /* -------------------------------------------------------------------- */
  210. #define MOD_VROW(Vmat, I, J, N, T, Q)            \
  211.     {                            \
  212.     short    k;                    \
  213.     for (k = 1; k <= N; ++k)            \
  214.     {                        \
  215.         USHORT  QVj[NE];                \
  216.         XMULT(Vmat + XML(J, k, T), Q, QVj);        \
  217.         XRSUB(Vmat + XML(I, k, T), QVj);        \
  218.     }                        \
  219.     }
  220. /* ----------------------------------------------------------- */
  221. /* PRT_RMAT - Prints 2 x 2 R Matrix in Two-Parameter Algorithm */
  222. /* ----------------------------------------------------------- */
  223. # if !defined(DEBUG)
  224. #define    PRT_RMAT(R11, R12, R21, R22)
  225. # else
  226. #define    PRT_RMAT(R11, R12, R21, R22)            \
  227.     {                            \
  228.     XPRINTF("R11: ", R11, 20);            \
  229.     XPRINTF("R12: ", R12, 20);            \
  230.     XPRINTF("R21: ", R21, 20);            \
  231.     XPRINTF("R22: ", R22, 20);            \
  232.     }
  233. # endif
  234. /* ----------------------------------------------------------- */
  235. /* SET_NEW_RMAT - Calculates new elements of Virtual Mmatrix R */
  236. /* ----------------------------------------------------------- */
  237. #define    SET_NEXT_RMAT(R11, R12, R21, R22, XA, XB, M)    \
  238.     {                                                   \
  239.     USHORT    Tmp1[NE];                               \
  240.     XMULT(R11, XB, Tmp1);                           \
  241.     XCOPY(R12, R11);                                \
  242.     XRMULT(R12, XA);                                \
  243.     XRADD(R12, Tmp1);                               \
  244.     XMULT(R21, XB, Tmp1);                           \
  245.     XCOPY(R22, R21);                                \
  246.     XRMULT(R22, XA);                                \
  247.     XRADD(R22, Tmp1);                               \
  248.     XMOD(R12, M, R12);                              \
  249.     XMOD(R22, M, R22);                              \
  250.     PRT_RMAT(R11, R12, R21, R22);            \
  251.     }
  252. /* -------------------------------------------------------------------- */
  253. /* SET_NEXT_UROW - Sets 1st, 2nd and last elements of new row in Umat    */
  254. /* -------------------------------------------------------------------- */
  255. #define SET_NEXT_UROW(Umat, NewT, R1, R2, T)        \
  256.     {                            \
  257.     XCOPY(R1, Umat + XML(NewT,1,T));        \
  258.     XNEG(Umat + XML(NewT,1,T));            \
  259.     XCOPY(R2, Umat + XML(NewT,2,T));        \
  260.     XNEG(Umat + XML(NewT,2,T));            \
  261.     XCOPY(EONE, Umat + XML(NewT,NewT,T));        \
  262.     }
  263. /* --------------------------------------------------- */
  264. /* TRANSFORM - Transforms U and V Matrices per Step S5 */
  265. /* --------------------------------------------------- */
  266. #define TRANSFORM(V, I, U, J, Vij, Vjj, N, T)        \
  267.     {                            \
  268.     USHORT    Q[NE];                    \
  269.     XDIV(Vij, Vjj, Q);                \
  270.     XROUND(Q, Q);                    \
  271.     MOD_VROW(V, I, J, N, T, Q);            \
  272.     MOD_UROW(U, J, I, N, T, Q);            \
  273.     }
  274. /* ----------------------------------------------- */
  275. /* VECPRT - Prints I-Element Vector A with Label S */
  276. /* ----------------------------------------------- */
  277. # if !defined(DEBUG)
  278. #    define VECPRT(A, I, S)
  279. # else
  280. #define VECPRT(A, I, S)                 \
  281.     {                            \
  282.     short    m;                    \
  283.     printf("%s\n", S);                \
  284.     for (m = 1; m <= I; ++m)             \
  285.     {                        \
  286.         char    Label[16];                \
  287.         sprintf(Label, "   (%2d) ", m);        \
  288.         XPRINTF(Label, A + XVL(m), NDEC);        \
  289.     }                        \
  290.     }
  291. # endif
  292. #include <float.h>
  293. /* Floating point debug print sequence */
  294. #define FIRE    \
  295.     {\
  296.     unsigned int    Status87 = _status87();\
  297.     if (Status87 != 0)\
  298.     {\
  299.      printf("Error File %s, Line %d, Status87 = %.4x\n",\
  300.          __FILE__, __LINE__, Status87);\
  301.      exit(1);\
  302.     }\
  303.     }
  304. /* ------------------- */
  305. /* FUNCTION PROTOTYPES */
  306. /* ------------------- */
  307. # undef F
  308. # if defined(__STDC__) || defined(__PROTO__)
  309. #    define  F( P )  P
  310. # else
  311. #    define  F( P )  ()
  312. # endif
  313.  
  314. /* INDENT OFF */
  315. extern    void    CalcMerit    F((void *, short, void *, void *));
  316. extern    void    EuclStep    F((void *, void *, void *, void *,
  317.                     void *, void *, void *));
  318. extern    void    fPutXFrac    F((FILE *, void *, short, short));
  319. extern    void    fPutXInt    F((FILE *, void *, short));
  320. extern    short    GetControlData    F((void *, void *, short *, short *));
  321. extern    void    GetGCD        F((void *, void *, void *));
  322. extern    void    GetShort    F((char *, short *));
  323. extern    void    GetStr        F((char *, char *));
  324. extern    void    PrintSprectalData F((void *, void *, short));
  325. extern    void    PutXFlt        F((void *, short, short));
  326. extern    void    PutXFrac    F((void *, short, short));
  327. extern    void    PutXInt        F((void *, short));
  328. extern    void    XdotProd    F((short, void *, void *, void *));
  329. extern    void    XmatPrt        F((void *, short, short, FILE *, char *));
  330. extern    void    Xmod        F((void *, void *, void *));
  331.  
  332. # undef F
  333. /* INDENT ON */
  334.  
  335. # endif            /* <<<__SPECTRAL_H__>>> */
  336.